NoMethodError in ConsolidacoesController#new

68
69
70
71
72
73
              

      end

      raise NotAuthorizedError, query: query, record: record, policy: policy unless policy.public_send(query)

      record
    end

68
69
70
71
72
73
              

      end

      raise NotAuthorizedError, query: query, record: record, policy: policy unless policy.public_send(query)

      record
    end

92
93
94
95
96
97
              

      @_pundit_policy_authorized = true

      pundit.authorize(record, query: query, policy_class: policy_class)
    end

    # Allow this action not to perform authorization.

4
5
6
7
8
9
              

  module BasicImplicitRender # :nodoc:
    def send_action(method, *args)
      ret = super
      default_render unless performed?
      ret
    end

222
223
224
225
226
227
              

      # which is *not* necessarily the same as the action name.
      def process_action(...)
        send_action(...)
      end

      # Actually call the method associated with the action. Override

163
164
165
166
167
168
              

      def process_action(*) # :nodoc:
        self.formats = request.formats.filter_map(&:ref)
        super
      end

      def _process_variant(options)

257
258
259
260
261
262
              

      def process_action(...)
        run_callbacks(:process_action) do
          super
        end
      end
  end

119
120
121
122
123
124
              

              current.invoke_before(env)
              if current.final?
                env.value = !env.halted && (!block_given? || yield)
              elsif current.skip?(env)
                (skipped ||= []) << current
                next_sequence = next_sequence.nested

22
23
24
25
26
27
              

    def with_request_id(request_id)
      old_request_id, self.current_request_id = self.current_request_id, request_id
      yield
    ensure
      self.current_request_id = old_request_id
    end

8
9
10
11
12
              

  private
    def turbo_tracking_request_id(&block)
      Turbo.with_request_id(request.headers["X-Turbo-Request-Id"], &block)
    end
end

128
129
130
131
132
133
              

                begin
                  target, block, method, *arguments = current.expand_call_template(env, invoke_sequence)
                  target.send(method, *arguments, &block)
                ensure
                  next_sequence = current
                end

21
22
23
24
25
26
              

        previous_renderer = self.renderer
        self.renderer = renderer
        yield
      ensure
        self.renderer = previous_renderer
      end

67
68
69
70
71
72
              

        ActiveSupport.on_load(base) do
          around_action do |controller, action|
            ActionText::Content.with_renderer(controller, &action)
          end
        end
      end

128
129
130
131
132
133
              

                begin
                  target, block, method, *arguments = current.expand_call_template(env, invoke_sequence)
                  target.send(method, *arguments, &block)
                ensure
                  next_sequence = current
                end

128
129
130
131
132
133
              

                begin
                  target, block, method, *arguments = current.expand_call_template(env, invoke_sequence)
                  target.send(method, *arguments, &block)
                ensure
                  next_sequence = current
                end

139
140
141
142
143
144
              

          end

          invoke_sequence.call
        end
      end
    end

256
257
258
259
260
261
              

      # <tt>process_action</tt> callbacks around the normal behavior.
      def process_action(...)
        run_callbacks(:process_action) do
          super
        end
      end

23
24
25
26
27
28
              

    private
      def process_action(*)
        super
      rescue Exception => exception
        request.env["action_dispatch.show_detailed_exceptions"] ||= show_detailed_exceptions?
        rescue_with_handler(exception) || raise

72
73
74
75
76
77
              

        ActiveSupport::Notifications.instrument("process_action.action_controller", raw_payload) do |payload|
          result = super
          payload[:response] = response
          payload[:status]   = response.status
          result

204
205
206
207
208
209
              

      def instrument(name, payload = {})
        if notifier.listening?(name)
          instrumenter.instrument(name, payload) { yield payload if block_given? }
        else
          yield payload if block_given?
        end

56
57
58
59
60
61
              

        handle.start
        begin
          yield payload if block_given?
        rescue Exception => e
          payload[:exception] = [e.class.name, e.message]
          payload[:exception_object] = e

204
205
206
207
208
209
              

      def instrument(name, payload = {})
        if notifier.listening?(name)
          instrumenter.instrument(name, payload) { yield payload if block_given? }
        else
          yield payload if block_given?
        end

71
72
73
74
75
76
              

        ActiveSupport::Notifications.instrument("start_processing.action_controller", raw_payload)

        ActiveSupport::Notifications.instrument("process_action.action_controller", raw_payload) do |payload|
          result = super
          payload[:response] = response
          payload[:status]   = response.status

259
260
261
262
263
264
              

      def process_action(*)
        _perform_parameter_wrapping if _wrapper_enabled?
        super
      end

      # Returns the wrapper key which will be used to store wrapped parameters.

30
31
32
33
34
35
              

          # and it won't be cleaned up by the method below.
          ActiveRecord::RuntimeRegistry.reset
          super
        end

        def cleanup_view_runtime

158
159
160
161
162
163
              

      @_response_body = nil

      process_action(action_name, *args)
    end
    ruby2_keywords(:process)

38
39
40
41
42
43
              

    def process(...) # :nodoc:
      old_config, I18n.config = I18n.config, I18nProxy.new(I18n.config, lookup_context)
      super
    ensure
      I18n.config = old_config
    end

225
226
227
228
229
230
              

      set_request!(request)
      set_response!(response)
      process(name)
      request.commit_flash
      to_a
    end

307
308
309
310
311
312
              

        middleware_stack.build(name) { |env| new.dispatch(name, req, res) }.call req.env
      else
        new.dispatch(name, req, res)
      end
    end
  end

47
48
49
50
51
52
              

          def dispatch(controller, action, req, res)
            controller.dispatch(action, req, res)
          end
      end

30
31
32
33
34
35
              

          controller = controller req
          res        = controller.make_response! req
          dispatch(controller, params[:action], req, res)
        rescue ActionController::RoutingError
          if @raise_on_name_error
            raise

49
50
51
52
53
54
              

          req.route_uri_pattern = route.path.spec.to_s

          _, headers, _ = response = route.app.serve(req)

          if "pass" == headers[Constants::X_CASCADE]
            req.script_name     = script_name

129
130
131
132
133
134
              

              path_parameters[name.to_sym] = Utils.unescape_uri(val) if val
            }
            yield [match_data, path_parameters, r]
          }
        end

122
123
124
125
126
127
              

          routes.sort_by!(&:precedence)

          routes.each { |r|
            match_data = r.path.match(path_info)
            path_parameters = {}
            match_data.names.each_with_index { |name, i|

122
123
124
125
126
127
              

          routes.sort_by!(&:precedence)

          routes.each { |r|
            match_data = r.path.match(path_info)
            path_parameters = {}
            match_data.names.each_with_index { |name, i|

30
31
32
33
34
35
              

      def serve(req)
        find_routes(req) do |match, parameters, route|
          set_params  = req.path_parameters
          path_info   = req.path_info
          script_name = req.script_name

880
881
882
883
884
885
              

        req = make_request(env)
        req.path_info = Journey::Router::Utils.normalize_path(req.path_info)
        @router.serve(req)
      end

      def recognize_path(path, environment = {})

34
35
36
37
38
39
              

      result = catch(:warden) do
        env['warden'].on_request
        @app.call(env)
      end

      result ||= {}

32
33
34
35
36
37
              

      env['warden'] = Proxy.new(env, self)
      result = catch(:warden) do
        env['warden'].on_request
        @app.call(env)
      end

32
33
34
35
36
37
              

      env['warden'] = Proxy.new(env, self)
      result = catch(:warden) do
        env['warden'].on_request
        @app.call(env)
      end

18
19
20
21
22
23
              

      begin
        _, _, body = response = @app.call(env)
      rescue Exception
        env[RACK_TEMPFILES]&.each(&:close!)
        raise

27
28
29
30
31
32
              

    def call(env)
      status, headers, body = response = @app.call(env)

      if etag_status?(status) && body.respond_to?(:to_ary) && !skip_caching?(headers)
        body = body.to_ary

29
30
31
32
33
34
              

      case env[REQUEST_METHOD]
      when "GET", "HEAD"
        status, headers, body = response = @app.call(env)

        if status == 200 && fresh?(env, headers)
          response[0] = 304

13
14
15
16
17
18
              

    def call(env)
      _, _, body = response = @app.call(env)

      if env[REQUEST_METHOD] == HEAD
        body.close if body.respond_to?(:close)

34
35
36
37
38
39
              

      def call(env)
        _, headers, _ = response = @app.call(env)

        return response if policy_present?(headers)

34
35
36
37
38
39
              

      def call(env)
        status, headers, _ = response = @app.call(env)

        # Returning CSP headers with a 304 Not Modified is harmful, since nonces in the new
        # CSP headers might not match nonces in the cached HTML.

272
273
274
275
276
277
              

          req = make_request env
          prepare_session(req)
          status, headers, body = app.call(req.env)
          res = Rack::Response::Raw.new status, headers
          commit_session(req, res)
          [status, headers, body]

266
267
268
269
270
271
              

        def call(env)
          context(env)
        end

        def context(env, app = @app)

687
688
689
690
691
692
              

    def call(env)
      request = ActionDispatch::Request.new(env)
      response = @app.call(env)

      if request.have_cookie_jar?
        cookie_jar = request.cookie_jar

653
654
655
656
657
658
              

        end

        @app.call(env)
      end

      private

27
28
29
30
31
32
              

      error = nil
      result = run_callbacks :call do
        @app.call(env)
      rescue => error
      end
      raise error if error

99
100
101
102
103
104
              

      if callbacks.empty?
        yield if block_given?
      else
        env = Filters::Environment.new(self, false, nil)

26
27
28
29
30
31
              

    def call(env)
      error = nil
      result = run_callbacks :call do
        @app.call(env)
      rescue => error
      end

12
13
14
15
16
17
              

      state = @executor.run!(reset: true)
      begin
        response = @app.call(env)

        if env["action_dispatch.report_exception"]
          error = env["action_dispatch.exception"]

14
15
16
17
18
19
              

    def call(env)
      request = ActionDispatch::Request.new(env)
      return @app.call(env) unless actionable_request?(request)

      ActiveSupport::ActionableError.dispatch(request.params[:error].to_s.safe_constantize, request.params[:action])

27
28
29
30
31
32
              

    def call(env)
      _, headers, body = response = @app.call(env)

      if headers[Constants::X_CASCADE] == "pass"
        body.close if body.respond_to?(:close)

130
131
132
133
134
135
              

      def call_app(env)
        @app.call(env)
      rescue => e
        throw :app_exception, e
      end

17
18
19
20
21
22
              

      app_exception = catch :app_exception do
        request = create_regular_or_whiny_request(env)
        return call_app(env) unless request.permitted?

        if id = id_for_repl_session_update(request)
          return update_repl_session(id, request)

15
16
17
18
19
20
              

    def call(env)
      app_exception = catch :app_exception do
        request = create_regular_or_whiny_request(env)
        return call_app(env) unless request.permitted?

15
16
17
18
19
20
              

    def call(env)
      app_exception = catch :app_exception do
        request = create_regular_or_whiny_request(env)
        return call_app(env) unless request.permitted?

29
30
31
32
33
34
              

    def call(env)
      @app.call(env)
    rescue Exception => exception
      request = ActionDispatch::Request.new env
      backtrace_cleaner = request.get_header("action_dispatch.backtrace_cleaner")

35
36
37
38
39
40
              

          logger.info { started_request_message(request) }
          status, headers, body = response = @app.call(env)
          body = ::Rack::BodyProxy.new(body, &handle.method(:finish))

          if response.frozen?

22
23
24
25
26
27
              

        if logger.respond_to?(:tagged)
          logger.tagged(*compute_tags(request)) { call_app(request, env) }
        else
          call_app(request, env)
        end

137
138
139
140
141
142
              

    def tagged(*tags)
      if block_given?
        formatter.tagged(*tags) { yield self }
      else
        logger = ActiveSupport::TaggedLogging.new(self)
        logger.formatter.extend LocalTagStorage

37
38
39
40
41
42
              

      def tagged(*tags)
        pushed_count = tag_stack.push_tags(tags).size
        yield self
      ensure
        pop_tags(pushed_count)
      end

137
138
139
140
141
142
              

    def tagged(*tags)
      if block_given?
        formatter.tagged(*tags) { yield self }
      else
        logger = ActiveSupport::TaggedLogging.new(self)
        logger.formatter.extend LocalTagStorage

239
240
241
242
243
244
              

          super(name, *args, **kwargs, &block)
        elsif loggers.one?
          loggers.first.send(name, *args, **kwargs, &block)
        else
          loggers.map { |logger| logger.send(name, *args, **kwargs, &block) }
        end

22
23
24
25
26
27
              

        if logger.respond_to?(:tagged)
          logger.tagged(*compute_tags(request)) { call_app(request, env) }
        else
          call_app(request, env)
        end

9
10
11
12
13
14
              

      ::Rails.logger.silence { @app.call(env) }
    else
      @app.call(env)
    end
  end
end

90
91
92
93
94
95
              

      req = ActionDispatch::Request.new env
      req.remote_ip = GetIp.new(req, check_ip, proxies)
      @app.call(req.env)
    end

    # The GetIp class exists as a way to defer processing of the request data

26
27
28
29
30
31
              

      req = ActionDispatch::Request.new env
      req.request_id = make_request_id(req.headers[@header])
      @app.call(env).tap { |_status, headers, _body| headers[@header] = req.request_id }
    end

    private

26
27
28
29
30
31
              

      end

      @app.call(env)
    end

    def method_override(env)

22
23
24
25
26
27
              

    def call(env)
      start_time = Utils.clock_time
      _, headers, _ = response = @app.call(env)

      request_time = Utils.clock_time - start_time

57
58
59
60
61
62
              

      response = nil
      events = @subscriber.collect_events do
        response = @app.call(env)
      end

      headers = response[1]

22
23
24
25
26
27
              

        events = []
        ActiveSupport::IsolatedExecutionState[KEY] = events
        yield
        events
      ensure
        ActiveSupport::IsolatedExecutionState.delete(KEY)

56
57
58
59
60
61
              

    def call(env)
      response = nil
      events = @subscriber.collect_events do
        response = @app.call(env)
      end

12
13
14
15
16
17
              

      state = @executor.run!(reset: true)
      begin
        response = @app.call(env)

        if env["action_dispatch.report_exception"]
          error = env["action_dispatch.exception"]

35
36
37
38
39
40
              

      end
    else
      @app.call(env)
    end
  end

23
24
25
26
27
28
              

    def call(env)
      @file_handler.attempt(env) || @app.call(env)
    end
  end

129
130
131
132
133
134
              

    def call(env)
      _, headers, body = response = @app.call(env)

      if body.respond_to?(:to_path)
        case type = variation(env)

332
333
334
335
336
337
              

          status, headers, body = [200, { Rack::CONTENT_TYPE => 'text/html' }, [blank_page_html.dup]] # important to dup here!
        else
          status, headers, body = @app.call(env)
        end
      ensure
        trace.disable if trace

534
535
536
537
538
539
              

    def call(env)
      req = build_request env
      app.call req.env
    end

    # Defines additional Rack env configuration that is added on each call.

277
278
279
280
281
282
              

      def call(env)
        env[Const::PUMA_CONFIG] = @config
        @app.call(env)
      end
    end

97
98
99
100
101
102
              

        if @supported_http_methods == :any || @supported_http_methods.key?(env[REQUEST_METHOD])
          status, headers, app_body = @thread_pool.with_force_shutdown do
            @app.call(env)
          end
        else
          @log_writer.log "Unsupported HTTP method used: #{env[REQUEST_METHOD]}"

388
389
390
391
392
393
              

        t[:with_force_shutdown] = true
      end
      yield
    ensure
      t[:with_force_shutdown] = false
    end

96
97
98
99
100
101
              

      begin
        if @supported_http_methods == :any || @supported_http_methods.key?(env[REQUEST_METHOD])
          status, headers, app_body = @thread_pool.with_force_shutdown do
            @app.call(env)
          end
        else

470
471
472
473
474
475
              

        while true
          @requests_count += 1
          case handle_request(client, requests + 1)
          when false
            break
          when :async

252
253
254
255
256
257
              

      @status = :run

      @thread_pool = ThreadPool.new(thread_name, options) { |client| process_client client }

      if @queue_requests
        @reactor = Reactor.new(@io_selector_backend) { |c| reactor_wakeup c }

165
166
167
168
169
170
              

          begin
            @out_of_band_pending = true if block.call(work)
          rescue Exception => e
            STDERR.puts "Error reached top of thread-pool: #{e.message} (#{e.class})"
          end